// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.supplier2;

import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class Supplier2SearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "Supplier2".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 供应商现有字段(模糊搜索)
   */
  private String supplierExistingFields;

  /**
   * 供应商现有字段 比较(eq)
   */
  private String supplierExistingFieldsEq;
  /**
   * 供应商现有字段 比较(neq)
   */
  private String supplierExistingFieldsNeq;
  /**
   * 供应商现有字段 比较(gt)
   */
  private String supplierExistingFieldsGt;
  /**
   * 供应商现有字段 比较(gte)
   */
  private String supplierExistingFieldsGte;
  /**
   * 供应商现有字段 比较(lt)
   */
  private String supplierExistingFieldsLt;
  /**
   * 供应商现有字段 比较(lte)
   */
  private String supplierExistingFieldsLte;
  /**
   * 供应商现有字段 比较(contains)
   */
  private String supplierExistingFieldsContains;
  /**
   * 供应商现有字段 比较(notcontains)
   */
  private String supplierExistingFieldsNotcontains;
  /**
   * 供应商现有字段 比较(startswith)
   */
  private String supplierExistingFieldsStartswith;
  /**
   * 供应商现有字段 比较(endswith)
   */
  private String supplierExistingFieldsEndswith;
  /**
   * 供应商现有字段 比较(isnull)
   */
  private Boolean supplierExistingFieldsIsnull;
  /**
   * 供应商现有字段 比较(isnotnull)
   */
  private Boolean supplierExistingFieldsIsnotnull;

  /**
   * 供应商现有字段(精确搜索)
   */
  private List<String> supplierExistingFieldsInList;

  /**
   * 编号
   */
  private Integer enterpriseId;

  /**
   * 最小编号
   */
  private Integer enterpriseIdMin;

  /**
   * 最大编号
   */
  private Integer enterpriseIdMax;

  /**
   * 编号 比较(eq)
   */
  private Integer enterpriseIdEq;
  /**
   * 编号 比较(neq)
   */
  private Integer enterpriseIdNeq;
  /**
   * 编号 比较(gt)
   */
  private Integer enterpriseIdGt;
  /**
   * 编号 比较(gte)
   */
  private Integer enterpriseIdGte;
  /**
   * 编号 比较(lt)
   */
  private Integer enterpriseIdLt;
  /**
   * 编号 比较(lte)
   */
  private Integer enterpriseIdLte;
  /**
   * 编号 比较(contains)
   */
  private Integer enterpriseIdContains;
  /**
   * 编号 比较(notcontains)
   */
  private Integer enterpriseIdNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Integer enterpriseIdStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Integer enterpriseIdEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean enterpriseIdIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean enterpriseIdIsnotnull;

  /**
   * 社会信用代码(模糊搜索)
   */
  private String socialCreditCode;

  /**
   * 社会信用代码 比较(eq)
   */
  private String socialCreditCodeEq;
  /**
   * 社会信用代码 比较(neq)
   */
  private String socialCreditCodeNeq;
  /**
   * 社会信用代码 比较(gt)
   */
  private String socialCreditCodeGt;
  /**
   * 社会信用代码 比较(gte)
   */
  private String socialCreditCodeGte;
  /**
   * 社会信用代码 比较(lt)
   */
  private String socialCreditCodeLt;
  /**
   * 社会信用代码 比较(lte)
   */
  private String socialCreditCodeLte;
  /**
   * 社会信用代码 比较(contains)
   */
  private String socialCreditCodeContains;
  /**
   * 社会信用代码 比较(notcontains)
   */
  private String socialCreditCodeNotcontains;
  /**
   * 社会信用代码 比较(startswith)
   */
  private String socialCreditCodeStartswith;
  /**
   * 社会信用代码 比较(endswith)
   */
  private String socialCreditCodeEndswith;
  /**
   * 社会信用代码 比较(isnull)
   */
  private Boolean socialCreditCodeIsnull;
  /**
   * 社会信用代码 比较(isnotnull)
   */
  private Boolean socialCreditCodeIsnotnull;

  /**
   * 社会信用代码(精确搜索)
   */
  private List<String> socialCreditCodeInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 是否有 老板身份证复印件
   */
  private Boolean bossIDCopyCard;

  /**
   * 是否有 营业执照
   */
  private Boolean businessLicense;

  /**
   * 是否有 注册资本
   */
  private Boolean registeredCapital;

  /**
   * 经营范围(模糊搜索)
   */
  private String businessScope;

  /**
   * 经营范围 比较(eq)
   */
  private String businessScopeEq;
  /**
   * 经营范围 比较(neq)
   */
  private String businessScopeNeq;
  /**
   * 经营范围 比较(gt)
   */
  private String businessScopeGt;
  /**
   * 经营范围 比较(gte)
   */
  private String businessScopeGte;
  /**
   * 经营范围 比较(lt)
   */
  private String businessScopeLt;
  /**
   * 经营范围 比较(lte)
   */
  private String businessScopeLte;
  /**
   * 经营范围 比较(contains)
   */
  private String businessScopeContains;
  /**
   * 经营范围 比较(notcontains)
   */
  private String businessScopeNotcontains;
  /**
   * 经营范围 比较(startswith)
   */
  private String businessScopeStartswith;
  /**
   * 经营范围 比较(endswith)
   */
  private String businessScopeEndswith;
  /**
   * 经营范围 比较(isnull)
   */
  private Boolean businessScopeIsnull;
  /**
   * 经营范围 比较(isnotnull)
   */
  private Boolean businessScopeIsnotnull;

  /**
   * 经营范围(精确搜索)
   */
  private List<String> businessScopeInList;

  /**
   * 地点(模糊搜索)
   */
  private String address;

  /**
   * 地点 比较(eq)
   */
  private String addressEq;
  /**
   * 地点 比较(neq)
   */
  private String addressNeq;
  /**
   * 地点 比较(gt)
   */
  private String addressGt;
  /**
   * 地点 比较(gte)
   */
  private String addressGte;
  /**
   * 地点 比较(lt)
   */
  private String addressLt;
  /**
   * 地点 比较(lte)
   */
  private String addressLte;
  /**
   * 地点 比较(contains)
   */
  private String addressContains;
  /**
   * 地点 比较(notcontains)
   */
  private String addressNotcontains;
  /**
   * 地点 比较(startswith)
   */
  private String addressStartswith;
  /**
   * 地点 比较(endswith)
   */
  private String addressEndswith;
  /**
   * 地点 比较(isnull)
   */
  private Boolean addressIsnull;
  /**
   * 地点 比较(isnotnull)
   */
  private Boolean addressIsnotnull;

  /**
   * 地点(精确搜索)
   */
  private List<String> addressInList;

  /**
   * 是否源头工厂
   */
  private Boolean ifSourceFactory;

  /**
   * 是否源头工厂
   */
  private String ifSourceFactoryEq;

  /**
   * 是否有 质量体系认证
   */
  private Boolean qualitySystemCertification;

  /**
   * 是否有 行业强制认证
   */
  private Boolean industryMandatoryCertification;

  /**
   * 是否有 知识产权
   */
  private Boolean intellectualProperty;

  /**
   * 设计人员(模糊搜索)
   */
  private String designers;

  /**
   * 设计人员 比较(eq)
   */
  private String designersEq;
  /**
   * 设计人员 比较(neq)
   */
  private String designersNeq;
  /**
   * 设计人员 比较(gt)
   */
  private String designersGt;
  /**
   * 设计人员 比较(gte)
   */
  private String designersGte;
  /**
   * 设计人员 比较(lt)
   */
  private String designersLt;
  /**
   * 设计人员 比较(lte)
   */
  private String designersLte;
  /**
   * 设计人员 比较(contains)
   */
  private String designersContains;
  /**
   * 设计人员 比较(notcontains)
   */
  private String designersNotcontains;
  /**
   * 设计人员 比较(startswith)
   */
  private String designersStartswith;
  /**
   * 设计人员 比较(endswith)
   */
  private String designersEndswith;
  /**
   * 设计人员 比较(isnull)
   */
  private Boolean designersIsnull;
  /**
   * 设计人员 比较(isnotnull)
   */
  private Boolean designersIsnotnull;

  /**
   * 设计人员(精确搜索)
   */
  private List<String> designersInList;

  /**
   * 打版师(模糊搜索)
   */
  private String typesetter;

  /**
   * 打版师 比较(eq)
   */
  private String typesetterEq;
  /**
   * 打版师 比较(neq)
   */
  private String typesetterNeq;
  /**
   * 打版师 比较(gt)
   */
  private String typesetterGt;
  /**
   * 打版师 比较(gte)
   */
  private String typesetterGte;
  /**
   * 打版师 比较(lt)
   */
  private String typesetterLt;
  /**
   * 打版师 比较(lte)
   */
  private String typesetterLte;
  /**
   * 打版师 比较(contains)
   */
  private String typesetterContains;
  /**
   * 打版师 比较(notcontains)
   */
  private String typesetterNotcontains;
  /**
   * 打版师 比较(startswith)
   */
  private String typesetterStartswith;
  /**
   * 打版师 比较(endswith)
   */
  private String typesetterEndswith;
  /**
   * 打版师 比较(isnull)
   */
  private Boolean typesetterIsnull;
  /**
   * 打版师 比较(isnotnull)
   */
  private Boolean typesetterIsnotnull;

  /**
   * 打版师(精确搜索)
   */
  private List<String> typesetterInList;

  /**
   * 排产人员(模糊搜索)
   */
  private String productionSchedulingPersonnel;

  /**
   * 排产人员 比较(eq)
   */
  private String productionSchedulingPersonnelEq;
  /**
   * 排产人员 比较(neq)
   */
  private String productionSchedulingPersonnelNeq;
  /**
   * 排产人员 比较(gt)
   */
  private String productionSchedulingPersonnelGt;
  /**
   * 排产人员 比较(gte)
   */
  private String productionSchedulingPersonnelGte;
  /**
   * 排产人员 比较(lt)
   */
  private String productionSchedulingPersonnelLt;
  /**
   * 排产人员 比较(lte)
   */
  private String productionSchedulingPersonnelLte;
  /**
   * 排产人员 比较(contains)
   */
  private String productionSchedulingPersonnelContains;
  /**
   * 排产人员 比较(notcontains)
   */
  private String productionSchedulingPersonnelNotcontains;
  /**
   * 排产人员 比较(startswith)
   */
  private String productionSchedulingPersonnelStartswith;
  /**
   * 排产人员 比较(endswith)
   */
  private String productionSchedulingPersonnelEndswith;
  /**
   * 排产人员 比较(isnull)
   */
  private Boolean productionSchedulingPersonnelIsnull;
  /**
   * 排产人员 比较(isnotnull)
   */
  private Boolean productionSchedulingPersonnelIsnotnull;

  /**
   * 排产人员(精确搜索)
   */
  private List<String> productionSchedulingPersonnelInList;

  /**
   * 生产人员(模糊搜索)
   */
  private String productionPersonnel;

  /**
   * 生产人员 比较(eq)
   */
  private String productionPersonnelEq;
  /**
   * 生产人员 比较(neq)
   */
  private String productionPersonnelNeq;
  /**
   * 生产人员 比较(gt)
   */
  private String productionPersonnelGt;
  /**
   * 生产人员 比较(gte)
   */
  private String productionPersonnelGte;
  /**
   * 生产人员 比较(lt)
   */
  private String productionPersonnelLt;
  /**
   * 生产人员 比较(lte)
   */
  private String productionPersonnelLte;
  /**
   * 生产人员 比较(contains)
   */
  private String productionPersonnelContains;
  /**
   * 生产人员 比较(notcontains)
   */
  private String productionPersonnelNotcontains;
  /**
   * 生产人员 比较(startswith)
   */
  private String productionPersonnelStartswith;
  /**
   * 生产人员 比较(endswith)
   */
  private String productionPersonnelEndswith;
  /**
   * 生产人员 比较(isnull)
   */
  private Boolean productionPersonnelIsnull;
  /**
   * 生产人员 比较(isnotnull)
   */
  private Boolean productionPersonnelIsnotnull;

  /**
   * 生产人员(精确搜索)
   */
  private List<String> productionPersonnelInList;

  /**
   * 财务行政人员(模糊搜索)
   */
  private String financialAdministrativePersonnel;

  /**
   * 财务行政人员 比较(eq)
   */
  private String financialAdministrativePersonnelEq;
  /**
   * 财务行政人员 比较(neq)
   */
  private String financialAdministrativePersonnelNeq;
  /**
   * 财务行政人员 比较(gt)
   */
  private String financialAdministrativePersonnelGt;
  /**
   * 财务行政人员 比较(gte)
   */
  private String financialAdministrativePersonnelGte;
  /**
   * 财务行政人员 比较(lt)
   */
  private String financialAdministrativePersonnelLt;
  /**
   * 财务行政人员 比较(lte)
   */
  private String financialAdministrativePersonnelLte;
  /**
   * 财务行政人员 比较(contains)
   */
  private String financialAdministrativePersonnelContains;
  /**
   * 财务行政人员 比较(notcontains)
   */
  private String financialAdministrativePersonnelNotcontains;
  /**
   * 财务行政人员 比较(startswith)
   */
  private String financialAdministrativePersonnelStartswith;
  /**
   * 财务行政人员 比较(endswith)
   */
  private String financialAdministrativePersonnelEndswith;
  /**
   * 财务行政人员 比较(isnull)
   */
  private Boolean financialAdministrativePersonnelIsnull;
  /**
   * 财务行政人员 比较(isnotnull)
   */
  private Boolean financialAdministrativePersonnelIsnotnull;

  /**
   * 财务行政人员(精确搜索)
   */
  private List<String> financialAdministrativePersonnelInList;

  /**
   * 是否有 现场图片
   */
  private Boolean livePictures;

  /**
   * 厂房(模糊搜索)
   */
  private String workShop;

  /**
   * 厂房 比较(eq)
   */
  private String workShopEq;
  /**
   * 厂房 比较(neq)
   */
  private String workShopNeq;
  /**
   * 厂房 比较(gt)
   */
  private String workShopGt;
  /**
   * 厂房 比较(gte)
   */
  private String workShopGte;
  /**
   * 厂房 比较(lt)
   */
  private String workShopLt;
  /**
   * 厂房 比较(lte)
   */
  private String workShopLte;
  /**
   * 厂房 比较(contains)
   */
  private String workShopContains;
  /**
   * 厂房 比较(notcontains)
   */
  private String workShopNotcontains;
  /**
   * 厂房 比较(startswith)
   */
  private String workShopStartswith;
  /**
   * 厂房 比较(endswith)
   */
  private String workShopEndswith;
  /**
   * 厂房 比较(isnull)
   */
  private Boolean workShopIsnull;
  /**
   * 厂房 比较(isnotnull)
   */
  private Boolean workShopIsnotnull;

  /**
   * 厂房(精确搜索)
   */
  private List<String> workShopInList;

  /**
   * 设备(模糊搜索)
   */
  private String device;

  /**
   * 设备 比较(eq)
   */
  private String deviceEq;
  /**
   * 设备 比较(neq)
   */
  private String deviceNeq;
  /**
   * 设备 比较(gt)
   */
  private String deviceGt;
  /**
   * 设备 比较(gte)
   */
  private String deviceGte;
  /**
   * 设备 比较(lt)
   */
  private String deviceLt;
  /**
   * 设备 比较(lte)
   */
  private String deviceLte;
  /**
   * 设备 比较(contains)
   */
  private String deviceContains;
  /**
   * 设备 比较(notcontains)
   */
  private String deviceNotcontains;
  /**
   * 设备 比较(startswith)
   */
  private String deviceStartswith;
  /**
   * 设备 比较(endswith)
   */
  private String deviceEndswith;
  /**
   * 设备 比较(isnull)
   */
  private Boolean deviceIsnull;
  /**
   * 设备 比较(isnotnull)
   */
  private Boolean deviceIsnotnull;

  /**
   * 设备(精确搜索)
   */
  private List<String> deviceInList;

  /**
   * 加工制造能力(模糊搜索)
   */
  private String processManufacturingCapacity;

  /**
   * 加工制造能力 比较(eq)
   */
  private String processManufacturingCapacityEq;
  /**
   * 加工制造能力 比较(neq)
   */
  private String processManufacturingCapacityNeq;
  /**
   * 加工制造能力 比较(gt)
   */
  private String processManufacturingCapacityGt;
  /**
   * 加工制造能力 比较(gte)
   */
  private String processManufacturingCapacityGte;
  /**
   * 加工制造能力 比较(lt)
   */
  private String processManufacturingCapacityLt;
  /**
   * 加工制造能力 比较(lte)
   */
  private String processManufacturingCapacityLte;
  /**
   * 加工制造能力 比较(contains)
   */
  private String processManufacturingCapacityContains;
  /**
   * 加工制造能力 比较(notcontains)
   */
  private String processManufacturingCapacityNotcontains;
  /**
   * 加工制造能力 比较(startswith)
   */
  private String processManufacturingCapacityStartswith;
  /**
   * 加工制造能力 比较(endswith)
   */
  private String processManufacturingCapacityEndswith;
  /**
   * 加工制造能力 比较(isnull)
   */
  private Boolean processManufacturingCapacityIsnull;
  /**
   * 加工制造能力 比较(isnotnull)
   */
  private Boolean processManufacturingCapacityIsnotnull;

  /**
   * 加工制造能力(精确搜索)
   */
  private List<String> processManufacturingCapacityInList;

  /**
   * 固定资产
   */
  private java.math.BigDecimal fixedAssets;

  /**
   * 最小固定资产
   */
  private java.math.BigDecimal fixedAssetsMin;

  /**
   * 最大固定资产
   */
  private java.math.BigDecimal fixedAssetsMax;

  /**
   * 固定资产 比较(eq)
   */
  private java.math.BigDecimal fixedAssetsEq;
  /**
   * 固定资产 比较(neq)
   */
  private java.math.BigDecimal fixedAssetsNeq;
  /**
   * 固定资产 比较(gt)
   */
  private java.math.BigDecimal fixedAssetsGt;
  /**
   * 固定资产 比较(gte)
   */
  private java.math.BigDecimal fixedAssetsGte;
  /**
   * 固定资产 比较(lt)
   */
  private java.math.BigDecimal fixedAssetsLt;
  /**
   * 固定资产 比较(lte)
   */
  private java.math.BigDecimal fixedAssetsLte;
  /**
   * 固定资产 比较(contains)
   */
  private java.math.BigDecimal fixedAssetsContains;
  /**
   * 固定资产 比较(notcontains)
   */
  private java.math.BigDecimal fixedAssetsNotcontains;
  /**
   * 固定资产 比较(startswith)
   */
  private java.math.BigDecimal fixedAssetsStartswith;
  /**
   * 固定资产 比较(endswith)
   */
  private java.math.BigDecimal fixedAssetsEndswith;
  /**
   * 固定资产 比较(isnull)
   */
  private Boolean fixedAssetsIsnull;
  /**
   * 固定资产 比较(isnotnull)
   */
  private Boolean fixedAssetsIsnotnull;

  /**
   * 流动资金
   */
  private java.math.BigDecimal currentAssets;

  /**
   * 最小流动资金
   */
  private java.math.BigDecimal currentAssetsMin;

  /**
   * 最大流动资金
   */
  private java.math.BigDecimal currentAssetsMax;

  /**
   * 流动资金 比较(eq)
   */
  private java.math.BigDecimal currentAssetsEq;
  /**
   * 流动资金 比较(neq)
   */
  private java.math.BigDecimal currentAssetsNeq;
  /**
   * 流动资金 比较(gt)
   */
  private java.math.BigDecimal currentAssetsGt;
  /**
   * 流动资金 比较(gte)
   */
  private java.math.BigDecimal currentAssetsGte;
  /**
   * 流动资金 比较(lt)
   */
  private java.math.BigDecimal currentAssetsLt;
  /**
   * 流动资金 比较(lte)
   */
  private java.math.BigDecimal currentAssetsLte;
  /**
   * 流动资金 比较(contains)
   */
  private java.math.BigDecimal currentAssetsContains;
  /**
   * 流动资金 比较(notcontains)
   */
  private java.math.BigDecimal currentAssetsNotcontains;
  /**
   * 流动资金 比较(startswith)
   */
  private java.math.BigDecimal currentAssetsStartswith;
  /**
   * 流动资金 比较(endswith)
   */
  private java.math.BigDecimal currentAssetsEndswith;
  /**
   * 流动资金 比较(isnull)
   */
  private Boolean currentAssetsIsnull;
  /**
   * 流动资金 比较(isnotnull)
   */
  private Boolean currentAssetsIsnotnull;

  /**
   * 应收应付账款
   */
  private java.math.BigDecimal receivablePayableAccounts;

  /**
   * 最小应收应付账款
   */
  private java.math.BigDecimal receivablePayableAccountsMin;

  /**
   * 最大应收应付账款
   */
  private java.math.BigDecimal receivablePayableAccountsMax;

  /**
   * 应收应付账款 比较(eq)
   */
  private java.math.BigDecimal receivablePayableAccountsEq;
  /**
   * 应收应付账款 比较(neq)
   */
  private java.math.BigDecimal receivablePayableAccountsNeq;
  /**
   * 应收应付账款 比较(gt)
   */
  private java.math.BigDecimal receivablePayableAccountsGt;
  /**
   * 应收应付账款 比较(gte)
   */
  private java.math.BigDecimal receivablePayableAccountsGte;
  /**
   * 应收应付账款 比较(lt)
   */
  private java.math.BigDecimal receivablePayableAccountsLt;
  /**
   * 应收应付账款 比较(lte)
   */
  private java.math.BigDecimal receivablePayableAccountsLte;
  /**
   * 应收应付账款 比较(contains)
   */
  private java.math.BigDecimal receivablePayableAccountsContains;
  /**
   * 应收应付账款 比较(notcontains)
   */
  private java.math.BigDecimal receivablePayableAccountsNotcontains;
  /**
   * 应收应付账款 比较(startswith)
   */
  private java.math.BigDecimal receivablePayableAccountsStartswith;
  /**
   * 应收应付账款 比较(endswith)
   */
  private java.math.BigDecimal receivablePayableAccountsEndswith;
  /**
   * 应收应付账款 比较(isnull)
   */
  private Boolean receivablePayableAccountsIsnull;
  /**
   * 应收应付账款 比较(isnotnull)
   */
  private Boolean receivablePayableAccountsIsnotnull;

  /**
   * 库存情况
   */
  private java.math.BigDecimal inventoryStatus;

  /**
   * 最小库存情况
   */
  private java.math.BigDecimal inventoryStatusMin;

  /**
   * 最大库存情况
   */
  private java.math.BigDecimal inventoryStatusMax;

  /**
   * 库存情况 比较(eq)
   */
  private java.math.BigDecimal inventoryStatusEq;
  /**
   * 库存情况 比较(neq)
   */
  private java.math.BigDecimal inventoryStatusNeq;
  /**
   * 库存情况 比较(gt)
   */
  private java.math.BigDecimal inventoryStatusGt;
  /**
   * 库存情况 比较(gte)
   */
  private java.math.BigDecimal inventoryStatusGte;
  /**
   * 库存情况 比较(lt)
   */
  private java.math.BigDecimal inventoryStatusLt;
  /**
   * 库存情况 比较(lte)
   */
  private java.math.BigDecimal inventoryStatusLte;
  /**
   * 库存情况 比较(contains)
   */
  private java.math.BigDecimal inventoryStatusContains;
  /**
   * 库存情况 比较(notcontains)
   */
  private java.math.BigDecimal inventoryStatusNotcontains;
  /**
   * 库存情况 比较(startswith)
   */
  private java.math.BigDecimal inventoryStatusStartswith;
  /**
   * 库存情况 比较(endswith)
   */
  private java.math.BigDecimal inventoryStatusEndswith;
  /**
   * 库存情况 比较(isnull)
   */
  private Boolean inventoryStatusIsnull;
  /**
   * 库存情况 比较(isnotnull)
   */
  private Boolean inventoryStatusIsnotnull;

  /**
   * 企业(模糊搜索)
   */
  private String enterprise;

  /**
   * 企业 比较(eq)
   */
  private String enterpriseEq;
  /**
   * 企业 比较(neq)
   */
  private String enterpriseNeq;
  /**
   * 企业 比较(gt)
   */
  private String enterpriseGt;
  /**
   * 企业 比较(gte)
   */
  private String enterpriseGte;
  /**
   * 企业 比较(lt)
   */
  private String enterpriseLt;
  /**
   * 企业 比较(lte)
   */
  private String enterpriseLte;
  /**
   * 企业 比较(contains)
   */
  private String enterpriseContains;
  /**
   * 企业 比较(notcontains)
   */
  private String enterpriseNotcontains;
  /**
   * 企业 比较(startswith)
   */
  private String enterpriseStartswith;
  /**
   * 企业 比较(endswith)
   */
  private String enterpriseEndswith;
  /**
   * 企业 比较(isnull)
   */
  private Boolean enterpriseIsnull;
  /**
   * 企业 比较(isnotnull)
   */
  private Boolean enterpriseIsnotnull;

  /**
   * 企业(精确搜索)
   */
  private List<String> enterpriseInList;

  /**
   * 法人(模糊搜索)
   */
  private String legalPerson;

  /**
   * 法人 比较(eq)
   */
  private String legalPersonEq;
  /**
   * 法人 比较(neq)
   */
  private String legalPersonNeq;
  /**
   * 法人 比较(gt)
   */
  private String legalPersonGt;
  /**
   * 法人 比较(gte)
   */
  private String legalPersonGte;
  /**
   * 法人 比较(lt)
   */
  private String legalPersonLt;
  /**
   * 法人 比较(lte)
   */
  private String legalPersonLte;
  /**
   * 法人 比较(contains)
   */
  private String legalPersonContains;
  /**
   * 法人 比较(notcontains)
   */
  private String legalPersonNotcontains;
  /**
   * 法人 比较(startswith)
   */
  private String legalPersonStartswith;
  /**
   * 法人 比较(endswith)
   */
  private String legalPersonEndswith;
  /**
   * 法人 比较(isnull)
   */
  private Boolean legalPersonIsnull;
  /**
   * 法人 比较(isnotnull)
   */
  private Boolean legalPersonIsnotnull;

  /**
   * 法人(精确搜索)
   */
  private List<String> legalPersonInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
